package es.duma.util.config;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Properties;
import java.util.ResourceBundle;

    /**
     * Clase para cargar las propiedades (java.util.Properties) desde un fichero
     * de configuracion .properties situado en el classpath.
     */
     public class ConfigurationLoader {
    
      /** Controla si debe lanzarse la excepcion al no poder acceder al fichero de propiedades */
      private static final boolean THROW_ON_LOAD_FAILURE = true;
      /**  */
      private static final boolean LOAD_AS_RESOURCE_BUNDLE = false;
      /** Extension del fichero de configuracion */
      private static final String SUFFIX = ".properties";

      /**
       * Constructor de la clase
       */
      private ConfigurationLoader()
      {
      } 

      /**
       * Busca en el classpath el fichero de configuracion pasado por el parametro name.
       *
       * @param name nombre del fichero de configuracion (no puede ser nulo)
       * @param loader classloader [null es equivalente al classloader de la aplicacion actual]
       *
       * @return fichero de configuracion en un objeto to java.util.Properties
       *
       * @throws IllegalArgumentException se lanza la excepcion si no se puede acceder al fichero y
       *         THROW_ON_LOAD_FAILURE vale true
       */
      public static Properties loadProperties(String name, ClassLoader loader)
      {
        if (name == null)
        {
          throw new IllegalArgumentException("null input: name");
        }

        if (name.startsWith("/"))
        {
          name = name.substring(1);
        }

        if (name.endsWith(SUFFIX))
        {
          name = name.substring(0, name.length() - SUFFIX.length());
        }

        Properties result = null;
        InputStream in = null;

        try
        {
          if (loader == null)
          {
            loader = ClassLoader.getSystemClassLoader();
          }

          if (LOAD_AS_RESOURCE_BUNDLE)
          {
            name = name.replace('/', '.');

            
            final ResourceBundle rb =
              ResourceBundle.getBundle(name, Locale.getDefault(), loader);
            result = new Properties();

            for (Enumeration keys = rb.getKeys(); keys.hasMoreElements();)
            {
              final String key = (String) keys.nextElement();
              final String value = rb.getString(key);
              result.put(key, value);
            }
          }
          else
          {
            name = name.replace('.', '/');

            if (!name.endsWith(SUFFIX))
            {
              name = name.concat(SUFFIX);
            }

            
            in = loader.getResourceAsStream(name);

            if (in != null)
            {
              result = new Properties();
              result.load(in); 
            }
          }
        }
        catch (Exception e)
        {
          result = null;
        }
        finally
        {
          if (in != null)
          {
            try
            {
              in.close();
            }
            catch (Throwable ignore)
            {
              ;
            }
          }
        }

        if (THROW_ON_LOAD_FAILURE && (result == null))
        {
          throw new IllegalArgumentException(
            "could not load [" + name + "]" + " as " +
            (LOAD_AS_RESOURCE_BUNDLE ? "a resource bundle" : "a classloader resource"));
        }

        return result;
      }

      /**
       * Metodo sobrecargado del metodo {@link #loadProperties(String, ClassLoader)}.
       * Carga el fichero de propiedades desde el clasppath actual.
       *
       * @param name nombre del fichero de configuracion (no puede ser nulo)
       *
       * @return fichero de configuracion en un objeto to java.util.Properties
       *
       */
      public static Properties loadProperties(final String name)
      {
        return loadProperties(name, Thread.currentThread().getContextClassLoader());
      }
    } 
